# Note that link order matters!
ALL_OBJS := $(BASEDIR)/common/common.o
ALL_OBJS += $(BASEDIR)/net/network.o
+ALL_OBJS += $(BASEDIR)/drivers/char/driver.o
ALL_OBJS += $(BASEDIR)/drivers/pci/driver.o
ALL_OBJS += $(BASEDIR)/drivers/net/driver.o
ALL_OBJS += $(BASEDIR)/drivers/block/driver.o
.long SYMBOL_NAME(kill_domain)
.long SYMBOL_NAME(do_dom0_op)
.long SYMBOL_NAME(do_network_op)
+ .long SYMBOL_NAME(do_block_io_op)
.long SYMBOL_NAME(do_set_debugreg)
.long SYMBOL_NAME(do_get_debugreg)
.long SYMBOL_NAME(do_update_descriptor)
extern void init_timervecs(void);
extern int setup_network_devices(void);
extern void net_init(void);
+ extern void initialize_block_io(void);
+ extern void initialize_serial(void);
+ extern void initialize_keyboard(void);
unsigned long low_mem_size;
pci_init();
#endif
do_initcalls();
+
+ initialize_serial(); /* setup serial 'driver' (for debugging) */
+ initialize_keyboard(); /* setup keyboard (also for debugging) */
+
if ( !setup_network_devices() )
panic("Must have a network device!\n");
- net_init(); /* initializes virtual network system. */
+ net_init(); /* initializes virtual network system. */
+ initialize_block_io(); /* setup block devices */
+
#ifdef CONFIG_SMP
wait_init_idle = cpu_online_map;
extern void schedule(void);
extern void flush_rx_queue(void);
+extern void flush_blk_queue(void);
/* Ordering must match definitions of _HYP_EVENT_* in xeno/sched.h */
static hyp_event_callback_fn_t event_call_fn[] =
{
schedule,
flush_rx_queue,
- kill_domain
+ kill_domain,
+ flush_blk_queue
};
/* Handle outstanding events for the currently-executing domain. */
default:
+ $(MAKE) -C char
$(MAKE) -C pci
$(MAKE) -C net
$(MAKE) -C block
$(MAKE) -C ide
+# $(MAKE) -C scsi
clean:
+ $(MAKE) -C char clean
$(MAKE) -C pci clean
$(MAKE) -C net clean
$(MAKE) -C block clean
$(MAKE) -C ide clean
+# $(MAKE) -C scsi clean
#include <xeno/slab.h>
#include <xeno/module.h>
+static void end_buffer_dummy(struct buffer_head *bh, int uptodate)
+{
+ /* do nothing */
+}
+
/* This will die as all synchronous stuff is coming to an end */
-#define end_buffer_io_sync NULL
#define complete(_r) panic("completion.h stuff may be needed...")
/*
*/
static inline void __generic_unplug_device(request_queue_t *q)
{
+ /* printk(KERN_ALERT "__generic_unplug_device %p %d\n", q, q->plugged); */
if (q->plugged) {
q->plugged = 0;
if (!list_empty(&q->queue_head))
+ {
+ /* printk(KERN_ALERT " calling %p\n", q->request_fn); */
q->request_fn(q);
+ }
}
}
request_queue_t *q = (request_queue_t *) data;
unsigned long flags;
+ /* printk(KERN_ALERT "generic_unplug_device\n"); */
+
spin_lock_irqsave(&io_request_lock, flags);
__generic_unplug_device(q);
spin_unlock_irqrestore(&io_request_lock, flags);
int latency;
elevator_t *elevator = &q->elevator;
+ /* printk(KERN_ALERT "__make_request\n");*/
+
count = bh->b_size >> 9;
sector = bh->b_rsector;
int minorsize = 0;
request_queue_t *q;
+ /* printk(KERN_ALERT "generic_make_request\n"); */
+
if (!bh->b_end_io)
BUG();
{
int count = bh->b_size >> 9;
+ /* printk(KERN_ALERT "submit_bh\n"); */
+
if (!test_bit(BH_Lock, &bh->b_state))
BUG();
* further remap this.
*/
bh->b_rdev = bh->b_dev;
- bh->b_rsector = bh->b_blocknr * count;
+ /* bh->b_rsector = bh->b_blocknr * count; */
generic_make_request(rw, bh);
int correct_size;
int i;
+ /* printk(KERN_ALERT "ll_rw_block %d %d\n", rw, nr); */
+
if (!nr)
return;
/* We have the buffer lock */
atomic_inc(&bh->b_count);
- bh->b_end_io = end_buffer_io_sync;
+ bh->b_end_io = end_buffer_dummy;
switch(rw) {
case WRITE:
if (!atomic_set_buffer_clean(bh))
/* Hmmph! Nothing to write */
goto end_io;
- __mark_buffer_clean(bh);
+ /* __mark_buffer_clean(bh); */
break;
case READA:
req->bh = bh->b_reqnext;
bh->b_reqnext = NULL;
bh->b_end_io(bh, uptodate);
+ end_block_io_op(bh);
if ((bh = req->bh) != NULL) {
req->hard_sector += nsect;
req->hard_nr_sectors -= nsect;
taskfile.device_head |= drive->select.all;
taskfile.command = command;
-#ifdef DEBUG
+ /* #ifdef DEBUG */
printk("%s: %sing: ", drive->name, (rq->cmd==READ) ? "read" : "writ");
if (lba) printk("LBAsect=%lld, ", block);
else printk("CHS=%d/%d/%d, ", cyl, head, sect);
printk("sectors=%ld, ", rq->nr_sectors);
printk("buffer=0x%08lx\n", (unsigned long) rq->buffer);
-#endif
+ /* #endif*/
memcpy(args.tfRegister, &taskfile, sizeof(struct hd_drive_task_hdr));
memcpy(args.hobRegister, &hobfile, sizeof(struct hd_drive_hob_hdr));
tasklets[9] = (task_ioreg_t) 0;
// tasklets[8] = (task_ioreg_t) (block>>32);
// tasklets[9] = (task_ioreg_t) (block>>40);
-#ifdef DEBUG
+ /*#ifdef DEBUG */
+ printk("[A]\n");
printk("%s: %sing: LBAsect=%lu, sectors=%ld, buffer=0x%08lx, LBAsect=0x%012lx\n",
drive->name,
(rq->cmd==READ)?"read":"writ",
drive->name, tasklets[3], tasklets[2],
tasklets[9], tasklets[8], tasklets[7],
tasklets[6], tasklets[5], tasklets[4]);
-#endif
+ /* #endif */
OUT_BYTE(tasklets[1], IDE_FEATURE_REG);
OUT_BYTE(tasklets[3], IDE_NSECTOR_REG);
OUT_BYTE(tasklets[7], IDE_SECTOR_REG);
struct hd_driveid *id = drive->id;
unsigned long capacity;
+
+ printk (KERN_ALERT
+ "ide-disk.c::idedisk_setup: chs %d %d %d\n",
+ drive->cyl, drive->head, drive->sect);
idedisk_add_settings(drive);
if ((capacity >= (drive->bios_cyl * drive->bios_sect * drive->bios_head)) &&
(!drive->forced_geom) && drive->bios_sect && drive->bios_head)
drive->bios_cyl = (capacity / drive->bios_sect) / drive->bios_head;
- printk (KERN_INFO "XEN %s: %ld sectors", drive->name, capacity);
+ printk (KERN_INFO "[XEN] %s: %ld sectors", drive->name, capacity);
/* Give size in megabytes (MB), not mebibytes (MiB). */
/* We compute the exact rounded value, avoiding overflow. */
#include <asm/uaccess.h>
#include <asm/io.h>
+#define IDE_PROBE_TRACE 0
+
static inline void do_identify (ide_drive_t *drive, byte cmd)
{
int bswap = 1;
struct hd_driveid *id;
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::do_identify\n");
+ }
+
id = drive->id = kmalloc (SECTOR_WORDS*4, GFP_ATOMIC); /* called with interrupts disabled! */
if (!id) {
printk(KERN_WARNING "(ide-probe::do_identify) Out of memory.\n");
unsigned long timeout;
byte s, a;
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::actual_try_to_identify\n");
+ }
+
if (IDE_CONTROL_REG) {
/* take a deep breath */
ide_delay_50ms();
int autoprobe = 0;
unsigned long cookie = 0;
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::try_to_identify\n");
+ }
+
if (IDE_CONTROL_REG && !HWIF(drive)->irq) {
autoprobe = 1;
cookie = probe_irq_on();
{
int rc;
ide_hwif_t *hwif = HWIF(drive);
+
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::do_probe\n");
+ }
+
if (drive->present) { /* avoid waiting for inappropriate probes */
if ((drive->media != ide_disk) && (cmd == WIN_IDENTIFY))
return 4;
{
unsigned long timeout;
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::enable_nest\n");
+ }
+
printk("%s: enabling %s -- ", HWIF(drive)->name, drive->id->model);
SELECT_DRIVE(HWIF(drive), drive);
ide_delay_50ms();
*/
static inline byte probe_for_drive (ide_drive_t *drive)
{
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::probe_for_drive\n");
+ }
+
if (drive->noprobe) /* skip probing? */
return drive->present;
if (do_probe(drive, WIN_IDENTIFY) >= 2) { /* if !(success||timed-out) */
unsigned int unit;
unsigned long flags;
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::probe_hwif\n");
+ }
+
if (hwif->noprobe)
return;
#ifdef CONFIG_BLK_DEV_IDE
{
unsigned int index;
int probe[MAX_HWIFS];
+
+ if (IDE_PROBE_TRACE)
+ {
+ printk (KERN_ALERT "ide-probe::ideprobe_init\n");
+ }
MOD_INC_USE_COUNT;
memset(probe, 0, MAX_HWIFS * sizeof(int));
struct hd_driveid *id = drive->id;
byte HIHI = (drive->addressing) ? 0xE0 : 0xEF;
+ printk(KERN_ALERT "do_rw_taskfile\n");
+
/* (ks/hs): Moved to start, do not use for multiple out commands */
if (task->handler != task_mulout_intr) {
if (IDE_CONTROL_REG)
block = rq->sector;
blockend = block + rq->nr_sectors;
+
+#ifdef NEVER
if ((rq->cmd == READ || rq->cmd == WRITE) &&
(drive->media == ide_disk || drive->media == ide_floppy)) {
if ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
possibly killing some innocent following sector */
if (block == 0 && drive->remap_0_to_1 == 1)
block = 1; /* redirect MBR access to EZ-Drive partn table */
+#endif
+
+#ifdef NEVER_DEBUG
+ {
+ printk(" ide::start_request %lx %lx %lx %lx %lx\n",
+ rq->sector, rq->nr_sectors, block,
+ drive->part[minor&PARTN_MASK].start_sect, drive->sect0);
+ }
+#endif
#if (DISK_RECOVERY_TIME > 0)
while ((read_timer() - hwif->last_time) < DISK_RECOVERY_TIME);
printk("%s: drive not ready for command\n", drive->name);
return startstop;
}
+ drive->special.all = 0;
if (!drive->special.all) {
switch(rq->cmd) {
case IDE_DRIVE_CMD:
default: $(OBJS)
$(MAKE) -C ne
$(MAKE) -C tulip
- $(MAKE) -C e1000
- $(LD) -r -o driver.o $(OBJS) tulip/tulip.o e1000/e1000.o ne/ne_drv.o
+ $(LD) -r -o driver.o $(OBJS) tulip/tulip.o ne/ne_drv.o
clean:
$(MAKE) -C ne clean
$(MAKE) -C tulip clean
- $(MAKE) -C e1000 clean
rm -f *.o *~ core
.PHONY: default clean
* These are the ring data structures for buffering messages between
* the hypervisor and guestos's.
*
- * For now we'll start with our own rings for the block IO code instead
- * of using the network rings. Hopefully, this will give us additional
- * flexibility in the future should we choose to move away from a
- * ring producer consumer communication model.
*/
#ifndef __BLOCK_H__
#define __BLOCK_H__
-typedef struct blk_tx_entry_st {
- unsigned long addr; /* virtual address */
- unsigned long size; /* in bytes */
-} blk_tx_entry_t;
+#include <linux/kdev_t.h>
-typedef struct blk_rx_entry_st {
- unsigned long addr; /* virtual address */
- unsigned long size; /* in bytes */
-} blk_rx_entry_t;
+/* the first four definitions match fs.h */
+#define XEN_BLOCK_READ 0
+#define XEN_BLOCK_WRITE 1
+#define XEN_BLOCK_READA 2 /* currently unused */
+#define XEN_BLOCK_SPECIAL 4 /* currently unused */
+#define XEN_BLOCK_PROBE 8 /* determine io configuration from hypervisor */
+#define XEN_BLOCK_DEBUG 16 /* debug */
-typedef struct blk_ring_st {
- blk_tx_entry_t *tx_ring;
- unsigned int tx_prod, tx_cons, tx_event;
- unsigned int tx_ring_size;
+#define XEN_BLOCK_SYNC 2
+#define XEN_BLOCK_ASYNC 3
- blk_rx_entry_t *rx_ring;
- unsigned int rx_prod, rx_cons, rx_event;
- unsigned int rx_ring_size;
+#define XEN_BLOCK_MAX_DOMAINS 32 /* NOTE: FIX THIS. VALUE SHOULD COME FROM? */
+
+#define BLK_TX_RING_SIZE 256
+#define BLK_RX_RING_SIZE 256
+
+#define BLK_TX_RING_MAX_ENTRIES (BLK_TX_RING_SIZE - 2)
+#define BLK_RX_RING_MAX_ENTRIES (BLK_RX_RING_SIZE - 2)
+
+#define BLK_TX_RING_INC(_i) (((_i)+1) & (BLK_TX_RING_SIZE-1))
+#define BLK_RX_RING_INC(_i) (((_i)+1) & (BLK_RX_RING_SIZE-1))
+#define BLK_TX_RING_ADD(_i,_j) (((_i)+(_j)) & (BLK_TX_RING_SIZE-1))
+#define BLK_RX_RING_ADD(_i,_j) (((_i)+(_j)) & (BLK_RX_RING_SIZE-1))
+
+typedef struct blk_ring_entry
+{
+ void * id; /* for guest os use; used for the bh */
+ int priority; /* orig sched pri, SYNC or ASYNC for now */
+ int operation; /* XEN_BLOCK_READ or XEN_BLOCK_WRITE */
+ char * buffer;
+ unsigned long block_number; /* block number */
+ unsigned short block_size; /* block size */
+ kdev_t device;
+ unsigned long sector_number; /* real buffer location on disk */
+} blk_ring_entry_t;
+
+typedef struct blk_ring_st
+{
+ blk_ring_entry_t *tx_ring;
+ unsigned int tx_prod, tx_cons;
+ unsigned int tx_ring_size;
+
+ blk_ring_entry_t *rx_ring;
+ unsigned int rx_prod, rx_cons;
+ unsigned int rx_ring_size;
} blk_ring_t;
-int blk_create_ring(int domain, unsigned long ptr);
+#define MAX_XEN_DISK_COUNT 100
+
+#define XEN_DISK_IDE 1
+#define XEN_DISK_SCSI 2
+
+typedef struct xen_disk /* physical disk */
+{
+ int type; /* disk type */
+ unsigned long capacity;
+ unsigned char heads; /* hdreg.h::hd_geometry */
+ unsigned char sectors; /* hdreg.h::hd_geometry */
+ unsigned int cylinders; /* hdreg.h::hd_big_geometry */
+ unsigned long start; /* hdreg.h::hd_geometry */
+ void * gendisk; /* struct gendisk ptr */
+} xen_disk_t;
+
+typedef struct xen_disk_info
+{
+ int count; /* number of subsequent xen_disk_t structures to follow */
+ xen_disk_t disks[100];
+} xen_disk_info_t;
#endif
#define __HYPERVISOR_exit 8
#define __HYPERVISOR_dom0_op 9
#define __HYPERVISOR_network_op 10
-#define __HYPERVISOR_set_debugreg 11
-#define __HYPERVISOR_get_debugreg 12
-#define __HYPERVISOR_update_descriptor 13
-#define __HYPERVISOR_set_fast_trap 14
+#define __HYPERVISOR_block_io_op 11
+#define __HYPERVISOR_set_debugreg 12
+#define __HYPERVISOR_get_debugreg 13
+#define __HYPERVISOR_update_descriptor 14
+#define __HYPERVISOR_set_fast_trap 15
#define TRAP_INSTR "int $0x82"
struct inode * b_inode;
struct list_head b_inode_buffers; /* doubly linked list of inode dirty buffers */
+ void *b_xen_request; /* xen request structure */
};
typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
#define CONFIG_IDEDMA_PCI_AUTO 1
#define CONFIG_IDEDMA_AUTO 1
#define CONFIG_BLK_DEV_IDE_MODES 1
+#define CONFIG_BLK_DEV_PIIX 1
#define CONFIG_SCSI 1
#define CONFIG_BLK_DEV_SD 1
-
#ifndef _LINUX_SCHED_H
#define _LINUX_SCHED_H
#define _HYP_EVENT_NEED_RESCHED 0
#define _HYP_EVENT_NET_RX 1
#define _HYP_EVENT_DIE 2
+#define _HYP_EVENT_BLK_RX 3
#define PF_DONEFPUINIT 0x1 /* Has the FPU been initialised for this task? */
#define PF_USEDFPU 0x2 /* Has this task used the FPU since last save? */
O_TARGET := blk.o
-obj-y := block.o
+obj-y := xl_block.o xl_block_test.o
include $(TOPDIR)/Rules.make
#ifdef CONFIG_SUN_JSFLASH
jsfd_init();
#endif
+
+#ifdef CONFIG_XENOLINUX_BLOCK
+ xlblk_init();
+#endif
+
return 0;
};
return ret;
}
+static inline int HYPERVISOR_block_io_op(void)
+{
+ int ret;
+ __asm__ __volatile__ (
+ TRAP_INSTR
+ : "=a" (ret) : "0" (__HYPERVISOR_block_io_op) );
+
+ return ret;
+}
+
static inline int HYPERVISOR_set_debugreg(int reg, unsigned long value)
{
int ret;
projects / xen.git / commitdiff